/**
 * 请求和响应拦截器
 * 可以在这里添加自定义的拦截器逻辑
 */

import AsyncStorage from '@react-native-async-storage/async-storage';
import { STORAGE_KEYS, API_CONFIG } from './config';

/**
 * 请求拦截器集合
 */
export const requestInterceptors = {
  // Token拦截器
  tokenInterceptor: async config => {
    try {
      const token = await AsyncStorage.getItem(STORAGE_KEYS.ACCESS_TOKEN);
      if (token) {
        config.headers = {
          ...config.headers,
          Authorization: `Bearer ${token}`,
        };
      }
    } catch {
      // Ignore token retrieval errors
    }
    return config;
  },

  // 语言拦截器
  languageInterceptor: async config => {
    try {
      const language =
        (await AsyncStorage.getItem(STORAGE_KEYS.LANGUAGE)) || 'zh-CN';
      config.headers = {
        ...config.headers,
        'Accept-Language': language,
      };
    } catch {
      // Ignore language retrieval errors
    }
    return config;
  },

  // 设备信息拦截器
  deviceInterceptor: config => {
    const deviceInfo = {
      platform: Platform.OS,
      version: Platform.Version,
      // 可以添加更多设备信息
    };

    config.headers = {
      ...config.headers,
      'X-Device-Info': JSON.stringify(deviceInfo),
    };

    return config;
  },

  // 请求日志拦截器
  logInterceptor: config => {
    return config;
  },
};

/**
 * 响应拦截器集合
 */
export const responseInterceptors = {
  // 成功响应拦截器
  successInterceptor: response => {
    return response;
  },

  // 错误响应拦截器
  errorInterceptor: async error => {
    // 处理特定错误
    switch (error.status) {
      case API_CONFIG.STATUS_CODES.UNAUTHORIZED:
        // Token过期，尝试刷新
        try {
          const refreshToken = await AsyncStorage.getItem(
            STORAGE_KEYS.REFRESH_TOKEN,
          );
          if (refreshToken) {
            // 这里应该调用刷新Token的逻辑
          } else {
            // 没有刷新Token，清除用户信息并跳转登录
            await AsyncStorage.multiRemove([
              STORAGE_KEYS.ACCESS_TOKEN,
              STORAGE_KEYS.REFRESH_TOKEN,
              STORAGE_KEYS.USER_INFO,
            ]);
            // 可以在这里触发跳转到登录页面的事件
          }
        } catch {
          // 刷新失败
        }
        break;

      case API_CONFIG.STATUS_CODES.FORBIDDEN:
        // 权限不足
        break;

      case API_CONFIG.STATUS_CODES.SERVER_ERROR:
        // 服务器错误
        break;
    }

    return Promise.reject(error);
  },

  // 数据转换拦截器
  dataTransformInterceptor: response => {
    // 统一处理响应数据格式
    if (response.data && typeof response.data === 'object') {
      // 假设后端返回格式为 { code, data, message }
      if (response.data.code !== undefined) {
        return {
          ...response,
          data: response.data.data,
          code: response.data.code,
          message: response.data.message,
        };
      }
    }
    return response;
  },

  // 缓存拦截器
  cacheInterceptor: response => {
    // 可以在这里实现响应缓存逻辑
    if (response.config?.cache && response.config.method === 'GET') {
      // 缓存GET请求的响应
      const cacheKey = `cache_${response.config.url}`;
      AsyncStorage.setItem(
        cacheKey,
        JSON.stringify({
          data: response.data,
          timestamp: Date.now(),
        }),
      ).catch(() => {
        // Ignore cache write errors
      });
    }
    return response;
  },
};

/**
 * 重试拦截器
 */
export const retryInterceptor = {
  // 请求重试配置
  retryConfig: {
    maxRetries: 3,
    retryDelay: 1000,
    retryCondition: error => {
      // 网络错误或5xx错误时重试
      return !error.response || error.response.status >= 500;
    },
  },

  // 重试逻辑
  retry: async (error, config) => {
    const retryCount = config.retryCount || 0;
    const maxRetries =
      config.maxRetries || retryInterceptor.retryConfig.maxRetries;

    if (
      retryCount < maxRetries &&
      retryInterceptor.retryConfig.retryCondition(error)
    ) {
      config.retryCount = retryCount + 1;

      // 延迟重试
      await new Promise(resolve => {
        setTimeout(
          resolve,
          retryInterceptor.retryConfig.retryDelay * retryCount,
        );
      });

      // 重新发送请求
      return httpRequest.request(config);
    }

    return Promise.reject(error);
  },
};

/**
 * 应用所有拦截器到HTTP请求实例
 */
export const applyInterceptors = httpInstance => {
  // 应用请求拦截器
  Object.values(requestInterceptors).forEach(interceptor => {
    httpInstance.addRequestInterceptor(interceptor);
  });

  // 应用响应拦截器
  httpInstance.addResponseInterceptor(
    responseInterceptors.successInterceptor,
    responseInterceptors.errorInterceptor,
  );

  httpInstance.addResponseInterceptor(
    responseInterceptors.dataTransformInterceptor,
  );

  httpInstance.addResponseInterceptor(responseInterceptors.cacheInterceptor);
};

/**
 * 自定义拦截器示例
 */
export const customInterceptors = {
  // 添加时间戳拦截器
  timestampInterceptor: config => {
    config.params = {
      ...config.params,
      _t: Date.now(),
    };
    return config;
  },

  // 添加签名拦截器（如果需要API签名）
  signatureInterceptor: _config => {
    // 这里可以添加API签名逻辑
    const signature = generateSignature(_config);
    _config.headers = {
      ..._config.headers,
      'X-Signature': signature,
    };
    return _config;
  },
};

// 生成签名的示例函数
function generateSignature(_config) {
  // 这里应该实现真实的签名算法
  return 'example_signature';
}
